home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Compression / Opener / Source / utils / arc / arcmisc.c < prev    next >
C/C++ Source or Header  |  1993-08-04  |  9KB  |  485 lines
  1. /*
  2.  * Miscellaneous routines to get ARC running on non-MSDOS systems...
  3.  * $Header: arcmisc.c,v 1.8 88/07/31 18:50:56 hyc Exp $ 
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include "arc.h"
  9.  
  10. #if    MSDOS
  11. #include <dir.h>
  12. #include <stat.h>
  13. #endif
  14.  
  15. #if    GEMDOS
  16. #include <osbind.h>
  17. #include <stat.h>
  18. char           *index(), *rindex();
  19.  
  20. void 
  21. exitpause()
  22. {
  23.     while (Cconis())
  24.         Cnecin();
  25.     fprintf(stderr, "Press any key to continue: ");
  26.     fflush(stderr);
  27.     Cnecin();
  28.     fprintf(stderr, "\n");
  29. }
  30.  
  31. int
  32. chdir(dirname)
  33.     char           *dirname;
  34. {
  35.     char           *i;
  36.     int             drv;
  37.  
  38.     i = dirname;
  39.     if ((i = index(dirname, ':')) != NULL) {
  40.         drv = i[-1];
  41.         i++;        /* Move past device spec */
  42.         if (drv > '\'')
  43.             drv -= 'a';
  44.         else
  45.             drv -= 'A';
  46.         if (drv >= 0 && drv < 16)
  47.             Dsetdrv(drv);
  48.     }
  49.     if (*i != '\0')
  50.         return (Dsetpath(i));
  51. }
  52. #endif
  53.  
  54. #if    UNIX
  55. #include <sys/types.h>
  56. #include <sys/dir.h>
  57. #include <sys/stat.h>
  58.     int    rename(), unlink();
  59. #endif
  60.  
  61. #if    SYSV
  62. #include <dirent.h>
  63. #define DIRECT dirent
  64. #else
  65. #define DIRECT direct
  66. #endif
  67.  
  68. #if    BSD
  69. #if    !NeXT
  70. char    *
  71. memset(s, c, n)        /* oops. Thought it was standard BSD, but my Sun */
  72.     char    *s;    /* fooled me again. -- hyc */
  73.     int    c, n;
  74. {
  75.     register int i;
  76.     for(i=0;i<n;i++)
  77.         s[i]=c;
  78.     return(s);
  79. }
  80. #endif
  81. #endif
  82.  
  83. char           *strcpy(), *strcat(), *malloc();
  84. //int             strlen(), strcmp(), match();
  85. // Changed by Subrata Sircar to eliminate strlen() compiler warning
  86. int             strcmp(), match();
  87.  
  88. int
  89. move(oldnam, newnam)
  90.     char           *oldnam, *newnam;
  91. {
  92.     FILE           *fopen(), *old, *new;
  93. #if    !MTS
  94.     struct stat     oldstat;
  95. #endif
  96.     char           *strcpy();
  97.     void        filecopy();
  98. #if    GEMDOS
  99.     if (Frename(0, oldnam, newnam))
  100. #else
  101.     if (rename(oldnam, newnam))
  102. #endif
  103. #if    !MTS
  104.     {
  105.         if (stat(oldnam, &oldstat))    /* different partition? */
  106.             return (-1);
  107.         old = fopen(oldnam, OPEN_R);
  108.         if (old == NULL)
  109.             return (-1);
  110.         new = fopen(newnam, OPEN_W);
  111.         if (new == NULL)
  112.             return (-1);
  113.         filecopy(old, new, oldstat.st_size);
  114.         return(unlink(oldnam));
  115.     }
  116.     return 0;
  117. #else
  118.     return(-1);
  119. #endif
  120. }
  121.  
  122. static void
  123. _makefn(source, dest)
  124.     char           *source;
  125.     char           *dest;
  126. {
  127.     int             j;
  128. #if    MSDOS
  129.     char           *setmem();
  130. #else
  131.     char           *memset();
  132. #endif
  133.  
  134.     setmem(dest, 17, 0);    /* clear result field */
  135.     for (j = 0; *source && *source != '.'; ++source)
  136.         if (j < 8)
  137.             dest[j++] = *source;
  138.     for (j = 9; *source; ++source)
  139.         if (j < 13)
  140.             dest[j++] = *source;
  141. }
  142. /*
  143.  * make a file name using a template 
  144.  */
  145.  
  146. char           *
  147. makefnam(rawfn, template, result)
  148.     char           *rawfn;    /* the original file name */
  149.     char           *template;    /* the template data */
  150.     char           *result;    /* where to place the result */
  151. {
  152.     char            et[17], er[17], rawbuf[STRLEN], *i, *rindex();
  153.  
  154.     *rawbuf = 0;
  155.     strcpy(rawbuf, rawfn);
  156. #if    MTS
  157.     i = rawbuf;
  158.     if (rawbuf[0] == tmpchr[0]) {
  159.         i++;
  160.         strcpy(rawfn, i);
  161.     } else
  162. #endif
  163.     if ((i = rindex(rawbuf, CUTOFF))) {
  164.         i++;
  165.         strcpy(rawfn, i);
  166.     }
  167. #if    DOS
  168.     else if ((i = rindex(rawbuf, ':'))) {
  169.         i++;
  170.         strcpy(rawfn, i);
  171.     }
  172. #endif
  173.     if (i)
  174.         *i = 0;
  175.     else
  176.         *rawbuf = 0;
  177.  
  178.     _makefn(template, et);
  179.     _makefn(rawfn, er);
  180.     *result = 0;        /* assure no data */
  181.     strcat(result, rawbuf);
  182.     strcat(result, er[0] ? er : et);
  183.     strcat(result, er[9] ? er + 9 : et + 9);
  184.     return ((char *) &result[0]);
  185. }
  186.  
  187. #if    MSDOS || SYSV
  188.  
  189. int
  190. alphasort(dirptr1, dirptr2)
  191.     struct DIRECT **dirptr1, **dirptr2;
  192. {
  193.     return (strcmp((*dirptr1)->d_name, (*dirptr2)->d_name));
  194. }
  195.  
  196. #endif
  197.  
  198. void
  199. upper(string)
  200.     char           *string;
  201. {
  202.     char           *p;
  203.  
  204.     for (p = string; *p; p++)
  205.         if (islower(*p))
  206.             *p = toupper(*p);
  207. }
  208. /* VARARGS1 */
  209. #if    !NeXT
  210. void
  211. abort(s, arg1, arg2, arg3)
  212.     char           *s;
  213. {
  214.     fprintf(stderr, "ARC: ");
  215.     fprintf(stderr, s, arg1, arg2, arg3);
  216.     fprintf(stderr, "\n");
  217. #if    UNIX
  218.     perror("UNIX");
  219. #endif
  220. #if    GEMDOS
  221.     exitpause();
  222. #endif
  223.     exit(1);
  224. }
  225. #endif
  226.  
  227. #if    !MTS
  228.  
  229. char           *
  230. gcdir(dirname)
  231.     char           *dirname;
  232.  
  233. {
  234.     char           *getwd();
  235. #if    GEMDOS
  236.     int             drv;
  237.     char           *buf;
  238. #endif
  239.     if (dirname == NULL || strlen(dirname) == 0)
  240.         dirname = (char *) malloc(1024);
  241.  
  242. #if    !GEMDOS
  243.     getwd(dirname);
  244. #else
  245.     buf = dirname;
  246.     *buf++ = (drv = Dgetdrv()) + 'A';
  247.     *buf++ = ':';
  248.     Dgetpath(buf, 0);
  249. #endif
  250.     return (dirname);
  251. }
  252.  
  253. #if    UNIX
  254. char           *pattern;    /* global so that fmatch can use it */
  255. #endif
  256.  
  257. char           *
  258. dir(filename)        /* get files, one by one */
  259.     char           *filename;    /* template, or NULL */
  260. {
  261. #if    GEMDOS
  262.     static int      Nnum = 0;
  263.     static DMABUFFER dbuf, *saved;
  264.     char           *name;
  265.  
  266.     if (Nnum == 0) {    /* first call */
  267.         saved = (DMABUFFER *) Fgetdta();
  268.         Fsetdta(&dbuf);
  269.         if (Fsfirst(filename, 0) == 0) {
  270.             name = malloc(FNLEN);
  271.             strcpy(name, dbuf.d_fname);
  272.             Nnum++;
  273.             return (name);
  274.         } else {
  275.             Fsetdta(saved);
  276.             return (NULL);
  277.         }
  278.     } else {
  279.         if (Fsnext() == 0) {
  280.             name = malloc(FNLEN);
  281.             strcpy(name, dbuf.d_fname);
  282.             return (name);
  283.         } else {
  284.             Nnum = 0;
  285.             Fsetdta(saved);
  286.             return (NULL);
  287.         }
  288.     }
  289. }
  290. #else
  291.     static struct DIRECT **namelist;
  292.     static char   **NameList;
  293.     static char    namecopy[STRLEN], *dirname;
  294. #if    UNIX
  295.     int             alphasort();
  296.     int             scandir();
  297. #endif                /* UNIX */
  298.     int             fmatch(), free();
  299.     static int      Nnum = 0, ii;
  300.     char        *rindex();
  301.  
  302.  
  303.     if (Nnum == 0) {    /* first call */
  304.         strcpy(namecopy,filename);
  305.         if(pattern=rindex(namecopy,CUTOFF)) {
  306.             *pattern = 0;
  307.             pattern++;
  308.             dirname = namecopy;
  309.         } else {
  310.             pattern = filename;
  311.             dirname = ".";
  312.         }
  313.         Nnum = scandir(dirname, &namelist, fmatch, alphasort);
  314.         NameList = (char **) malloc(Nnum * sizeof(char *));
  315.         for (ii = 0; ii < Nnum; ii++) {
  316.             (NameList)[ii] = malloc(strlen(namelist[ii]->d_name) + 1);
  317.             strcpy((NameList)[ii], namelist[ii]->d_name);
  318.         }
  319.         ii = 0;
  320.     }
  321.     if (ii >= Nnum) {    /* all out of files */
  322.         if (Nnum) {    /* there were some files found */
  323.             for (ii = 0; ii < Nnum; ii++)
  324.                 free(namelist[ii]);
  325.             free(namelist);
  326.         }
  327.         Nnum = 0;
  328.         return (NULL);
  329.     } else {
  330.         return ((NameList)[ii++]);
  331.     }
  332. }
  333.  
  334. /*
  335.  * Filename match - here, * matches everything 
  336.  */
  337.  
  338. int
  339. fmatch(direntry)
  340.     struct DIRECT  *direntry;
  341. {
  342.     char           *string;
  343.  
  344.     string = direntry->d_name;
  345.  
  346.     if (!strcmp(pattern, "") || !strcmp(pattern, "*.*") || !strcmp(pattern, "*"))
  347.         return (1);
  348.     return (match(string, pattern));
  349. }
  350. #endif                /* GEMDOS */
  351. #else
  352. /* dir code for MTS under Bell Labs C... */
  353.  
  354. char           *
  355. dir(filepattern)
  356.     char           *filepattern;    /* template or NULL */
  357. {
  358.     char           *malloc(), *index();
  359. #if    USECATSCAN
  360.     fortran void    catscan(), fileinfo();
  361.  
  362.     struct catname {
  363.         short           len;
  364.         char            name[257];
  365.     }               pattern;
  366.  
  367.     struct catval {
  368.         int             maxlen;
  369.         int             actlen;
  370.         char            name[257];
  371.     }               catreturn;
  372.  
  373.     char           *i;
  374.     int             j, RETCODE;
  375.  
  376.     static int      catptr = 0;
  377.     static int      catflag = 0x200;
  378.     static int      cattype = 1;
  379.     static int      patflag = 0;
  380.  
  381.     catreturn.maxlen = 256;
  382.  
  383.     if (patflag) {
  384.         patflag = 0;
  385.         catptr = 0;
  386.         return (NULL);
  387.     }
  388.     if (filepattern) {
  389.         strcpy(pattern.name, filepattern);
  390.         pattern.len = strlen(filepattern);
  391.         if (!index(filepattern, '?'))
  392.             patflag = 1;
  393.     }
  394.     if (patflag) {
  395.         fileinfo(&pattern, &cattype, "CINAME  ", &catreturn, _retcode RETCODE);
  396.         catptr = RETCODE ? 0 : 1;
  397.     } else
  398.         catscan(&pattern, &catflag, &cattype, &catreturn, &catptr);
  399.  
  400.     if (!catptr)
  401.         return (NULL);
  402.     else {
  403.         char           *k;
  404.  
  405.         k = index(catreturn.name, ' ');
  406.         if (k)
  407.             *k = 0;
  408.         else {
  409.             j = catreturn.actlen;
  410.             catreturn.name[j] = 0;
  411.         }
  412.         k = catreturn.name;
  413.         if (catreturn.name[0] == tmpchr[0])
  414.             k++;
  415.         else if ((k = index(catreturn.name, sepchr[0])))
  416.             k++;
  417.         else
  418.             k = catreturn.name;
  419.         j = strlen(k);
  420.         i = malloc(++j);
  421.         strcpy(i, k);
  422.         return (i);
  423.     }
  424. #else
  425.     fortran void    gfinfo();
  426.     static char     gfname[24];
  427.     static char     pattern[20];
  428.     static int      gfdummy[2] = {
  429.                       0, 0
  430.     },              gfflags;
  431.     int             i, RETCODE;
  432.     char           *j, *k;
  433.  
  434.     if (filepattern) {
  435.         strcpy(pattern, filepattern);
  436.         strcat(pattern, " ");
  437.         for (i = 20; i < 24; i++)
  438.             gfname[i] = '\0';
  439.         if (index(pattern, '?'))
  440.             gfflags = 0x0C;
  441.         else
  442.             gfflags = 0x09;
  443.     } else if (gfflags == 0x09)
  444.         return (NULL);
  445.  
  446.     gfinfo(pattern, gfname, &gfflags, gfdummy, gfdummy, gfdummy, _retcode RETCODE);
  447.     if (RETCODE)
  448.         return (NULL);
  449.     else {
  450.         k = index(gfname, ' ');
  451.         *k = '\0';
  452.         k = gfname;
  453.         if (gfname[0] == tmpchr[0])
  454.             k++;
  455.         else if ((k = index(gfname, sepchr[0])))
  456.             k++;
  457.         else
  458.             k = gfname;
  459.         i = strlen(k);
  460.         j = malloc(++i);
  461.         strcpy(j, k);
  462.         return (j);
  463.     }
  464. #endif
  465. }
  466.  
  467. int
  468. unlink(path)
  469.     char           *path;    /* name of file to delete */
  470. {
  471.     fortran void    destroy();
  472.     int             RETCODE;
  473.  
  474.     char            name[258];
  475.  
  476.     strcpy(name, path);
  477.     strcat(name, " ");
  478.     destroy(name, _retcode RETCODE);
  479.     if (RETCODE)
  480.         return (-1);
  481.     else
  482.         return (0);
  483. }
  484. #endif
  485.